package com.dolphin.aiagentplatform.service.impl;

import com.dolphin.aiagentplatform.ai.constant.AgentTypeConst;
import com.dolphin.aiagentplatform.model.vo.user.UserVO;
import com.dolphin.aiagentplatform.service.ChatMessageService;
import com.dolphin.aiagentplatform.service.ChatSessionService;
import com.dolphin.aiagentplatform.service.ChatTransactionService;
import com.dolphin.aiagentplatform.service.UserLatestChatService;
import com.dolphin.aiagentplatform.utils.ChatIdGenerator;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

/**
 * 聊天事务服务实现类
 * 提供聊天相关事务管理
 */
@Service
@RequiredArgsConstructor
@Slf4j
public class ChatTransactionServiceImpl implements ChatTransactionService {

    private final ChatSessionService chatSessionService;
    private final UserLatestChatService userLatestChatService;
    private final ChatMessageService chatMessageService;
    private final ChatIdGenerator chatIdGenerator;

    /**
     * 处理聊天会话创建或更新
     * 包含事务管理，确保会话创建和最近聊天更新的原子性
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public String processChatSession(String chatId, Long userId, AgentTypeConst agentTypeConst) {
        String finalChatId = chatId;
        
        if (!StringUtils.hasText(finalChatId)) {
            // 尝试获取用户最近的聊天ID
            finalChatId = userLatestChatService.getLatestChatId(userId, agentTypeConst.toString());
            
            if (finalChatId == null) {
                // 如果没有，生成一个新的
                UserVO userVO = new UserVO();
                userVO.setId(userId);
                finalChatId = chatIdGenerator.generateChatId(userVO, agentTypeConst);
                // 保存聊天会话
                chatSessionService.saveChatSession(finalChatId, userId, agentTypeConst.toString());
                log.debug("为用户自动创建新对话，userId:{}, chatId:{}", userId, finalChatId);
            } else {
                log.debug("使用用户最近的对话，userId:{}, chatId:{}", userId, finalChatId);
            }
        }
        
        // 更新用户最近使用的聊天ID
        userLatestChatService.updateLatestChatId(userId, finalChatId, agentTypeConst.toString());
        return finalChatId;
    }

    /**
     * 批量保存聊天消息
     * 包含事务管理，确保多条消息保存的原子性
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void saveChatMessages(String chatId, Long userId, String[] roles, String[] contents, String modelType) {
        // 验证参数
        if (roles.length != contents.length) {
            throw new IllegalArgumentException("角色和内容数组长度不匹配");
        }
        
        // 批量保存消息
        for (int i = 0; i < roles.length; i++) {
            String role = roles[i];
            String content = contents[i];
            // 只有当内容不为空时才保存
            if (StringUtils.hasText(content)) {
                chatMessageService.saveChatMessage(chatId, userId, role, content, modelType);
            }
        }
    }

    /**
     * 保存完整对话（作为一个事务）
     * 确保system、user和assistant消息作为原子操作一起保存或回滚
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void saveCompleteConversation(String chatId, Long userId, String systemPrompt, 
                                        String userPrompt, String assistantResponse, String modelType) {
        log.debug("开始保存完整对话，chatId:{}, userId:{}", chatId, userId);
        
        // 1. 保存系统提示（如果有）
        if (StringUtils.hasText(systemPrompt)) {
            chatMessageService.saveChatMessage(chatId, userId, "system", systemPrompt, modelType);
        }
        
        // 2. 保存用户消息（必须有）
        if (!StringUtils.hasText(userPrompt)) {
            throw new IllegalArgumentException("用户消息不能为空");
        }
        chatMessageService.saveChatMessage(chatId, userId, "user", userPrompt, modelType);
        
        // 3. 保存助手响应（必须有）
        if (!StringUtils.hasText(assistantResponse)) {
            throw new IllegalArgumentException("助手响应不能为空");
        }
        chatMessageService.saveChatMessage(chatId, userId, "assistant", assistantResponse, modelType);
        
        log.debug("完整对话保存成功，chatId:{}, userId:{}", chatId, userId);
    }

    /**
     * 保存完整对话（作为一个事务）并更新会话标题
     * 确保system、user和assistant消息作为原子操作一起保存或回滚，同时更新会话标题
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void saveConversationAndUpdateTitle(String chatId, Long userId, String systemPrompt, 
                                        String userPrompt, String assistantResponse, String modelType) {
        log.debug("开始保存完整对话并更新会话标题，chatId:{}, userId:{}", chatId, userId);
        
        // 1. 先保存完整对话
        saveCompleteConversation(chatId, userId, systemPrompt, userPrompt, assistantResponse, modelType);
        
        // 2. 提取用户消息作为会话标题（取前50个字符，避免标题过长）
        String sessionTitle = userPrompt;
        if (sessionTitle.length() > 50) {
            sessionTitle = sessionTitle.substring(0, 47) + "...";
        }
        
        // 3. 更新会话标题
        boolean result = chatSessionService.updateChatSessionTitle(chatId, sessionTitle);
        
        if (result) {
            log.debug("会话标题更新成功，chatId:{}, title:{}", chatId, sessionTitle);
        } else {
            log.warn("会话标题更新失败，chatId:{}, title:{}", chatId, sessionTitle);
        }
    }
} 